package com.TanNgee.netty.kyro.server;

import com.TanNgee.netty.kyro.codec.NettyKryoDecoder;
import com.TanNgee.netty.kyro.codec.NettyKryoEncoder;
import com.TanNgee.netty.kyro.dto.RpcRequest;
import com.TanNgee.netty.kyro.dto.RpcResponse;
import com.TanNgee.netty.kyro.serialize.KryoSerializer;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.netty.channel.ChannelInitializer;

/**
 * @author 陈毅
 * @create 2022/3/11 17:13
 */

//https://www.cnblogs.com/lbhym/p/12753314.html

/*
主要作用就是开启了一个服务端用于接受客户端的请求并处理。
 */
public class NettyServer {
    private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);
    private final int port;

    // 通信端口
    public NettyServer(int port) {
        this.port = port;
    }

    private void run() {
        /**
         * 两个NioEventLoopGroup对象，可以看作两个线程组。
         * bossGroup的作用是监听客户端请求。
         * workerGroup的作用是处理每条连接的数据读写
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        KryoSerializer kryoSerializer = new KryoSerializer();

        try {
            ServerBootstrap b = new ServerBootstrap(); //（启动引导类）

            b.group(bossGroup, workerGroup)

                    //channel是配置服务端的IO模型，配置的是NIO模型
                    .channel(NioServerSocketChannel.class)

                    // option: 给服务端的channel设置属性
                    //表示系统用于临时存放已完成三次握手的请求的队列的最大长度,如果连接建立频繁，服务器处理创建新连接较慢，可以适当调大这个参数
                    .option(ChannelOption.SO_BACKLOG, 128)

                    //childOption：给每条客户端连接设置TCP相关的属性
                    // TCP默认开启了 Nagle 算法，该算法的作用是尽可能的发送大数据快，减少网络传输。TCP_NODELAY 参数的作用就是控制是否启用 Nagle 算法。
                    .childOption(ChannelOption.TCP_NODELAY, true)
                    // 是否开启 TCP 底层心跳机制
                    .childOption(ChannelOption.SO_KEEPALIVE, true)

                    //指定服务端启动中的逻辑
                    .handler(new LoggingHandler(LogLevel.INFO))
                    //配置每条连接的数据读写和业务逻辑等
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        /*
                             自定义序列化编解码器
                             */
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            // ch.pipeline().addLast()  :添加一个逻辑处理器 (channelHandler)

                            // RpcResponse -> ByteBuf
                            ch.pipeline().addLast(new NettyKryoDecoder(kryoSerializer, RpcRequest.class));

                            // ByteBuf -> RpcRequest
                            ch.pipeline().addLast(new NettyKryoEncoder(kryoSerializer, RpcResponse.class));

                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });

            // 绑定端口，同步等待绑定成功
            ChannelFuture f = b.bind(port).sync();
            // 等待服务端监听端口关闭
            f.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            logger.error("occur exception when start server:", e);
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        new NettyServer(8889).run();
    }
}
